{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO0AAABECAYAAABtXrKpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAB/klEQVR4nO3YMYrUYBzG4X+GDaLDuIWewGIu4BksvIqVILZewMrGUvAUFp7BC0xrJ6uwu2RFAvNZyFo4RhA2m331ecp8zRvIj5mka621AmKslh4A/B3RQhjRQhjRQpijqYP9fl/DMFTf99V13XVugv9aa63Gcaz1el2r1eHv6mS0wzDUbrebdRwwbbvd1mazObg+GW3f91VV9ezVmzo5PZtv2YLevnhar989X3rGbJ48flmr9x+WnjGb/aOHdbF/sPSMK9fVWLdXH382+KvJaC//Ep+cntWnL6fzrLsBTi8+Lz1hVt3Xb0tPmFWr3z/Y/4Kp11IfoiCMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCGMaCHM0dRBa62qqu4f3722MUs4vnNv6QmzardvLT1hVl2NS0+4cpf3dNngwXmbODk/P6/dbjffMuCPttttbTabg+uT0e73+xqGofq+r67rZh8I/NBaq3Eca71e12p1+AY7GS1wM/kQBWFEC2FEC2FEC2G+A7O0WWjJZuMgAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 288x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# load required packages\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import statsmodels.api as sm\n",
    "import pickle\n",
    "import joblib\n",
    "from __future__ import division\n",
    "from IPython.display import display\n",
    "from itertools import product\n",
    "\n",
    "# set styling for plots\n",
    "%matplotlib inline  \n",
    "sns.set(style = \"whitegrid\")\n",
    "sns.set_palette('cubehelix',4)\n",
    "plt.rc('text', usetex=True)\n",
    "plt.rc('font', family='serif')\n",
    "sns.palplot(sns.color_palette())\n",
    "\n",
    "# define names of models\n",
    "clfs = [\"LogitNonLinear\",\"RandomForestIsotonic\"]\n",
    "outnames = {clfs[0]: \"Nonlinear Logit\",clfs[1]: \"Random Forest\",\"Difference\" : \"Difference\"}\n",
    "\n",
    "# set race categories for plots\n",
    "plotrace = [\"Asian\",\"White Non-Hispanic\",\"White Hispanic\",\"Black\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters \n",
    "params = {'av_premium': 0.3, 'loss_prop_to' : 'ltv', 'gamma': 1, 'delta' : 0.75, 'phi' : 0.1,\n",
    "         'sda_adjusted' : True, 'bias' : 0.411}\n",
    "\n",
    "# sda parameters\n",
    "sda_params = {'high': 0.006, 'high_start': 30, 'high_end': 60,\n",
    "                'low' : 0.0003, 'low_start': 120, 'measured_cumulative' : 36, 'T' : 360}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup utilities and solution algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bias correction\n",
    "def adjust(p,b,base_index,epsilon = 0.0001):\n",
    "    t = np.log(-np.log(1-p)+epsilon).values\n",
    "    tbase = t[:,base_index].reshape(-1,1)\n",
    "    newt = b * tbase + (1-b) * t\n",
    "    newp = 1- np.exp(epsilon - np.exp(newt))\n",
    "    return newp\n",
    "\n",
    "# sda adjustment\n",
    "def sda(p,sda_params):\n",
    "    T = sda_params[\"T\"]\n",
    "    hmax = sda_params[\"high\"]\n",
    "    hmin = sda_params[\"low\"]\n",
    "    t1 = sda_params[\"high_start\"]\n",
    "    t2 = sda_params[\"high_end\"]\n",
    "    t3 = sda_params[\"low_start\"]\n",
    "    t_hat = sda_params[\"measured_cumulative\"]\n",
    "    H = hmin * (2*T - t2 - t3) / 2 + hmax * (t2 + t3 - t1) / 2\n",
    "    log_survival_adjustment = H / (hmax*(t_hat - 0.5*t1))\n",
    "    log_survival = np.log(1-p) * log_survival_adjustment\n",
    "    newp = 1- np.exp(log_survival)\n",
    "    return newp\n",
    "\n",
    "# bins for logit prediction\n",
    "def mkbins(df):\n",
    "    bins = pd.DataFrame(index = df.index)\n",
    "\n",
    "    fico_cuts = [0] + list(range(280,870,20))\n",
    "    fico_bin = pd.cut(df[\"fico_orig_fill\"], fico_cuts, labels = fico_cuts[0:-1], right = False).fillna(0)\n",
    "    fico_bin.loc[(fico_bin>0) & (fico_bin < 600),] = 600\n",
    "    fico_bin.loc[fico_bin==840,] = 820\n",
    "#     fico_bin = fico_bin.cat.remove_unused_categories()\n",
    "\n",
    "    ltv_cuts = list(range(20,110,5))\n",
    "    ltv_bin = pd.cut(df[\"ltv_ratio_fill\"], ltv_cuts, labels = ltv_cuts[0:-1], right = False)\n",
    "    ltv_80 = (df[\"ltv_ratio_fill\"]==80).astype(int)    \n",
    "\n",
    "    inc_cuts = list(range(-25,550,25))\n",
    "    income_bin = pd.cut(df[\"applicant_income\"],inc_cuts, labels = inc_cuts[0:-1],right = False)\n",
    "\n",
    "    bins = bins.join(pd.get_dummies(fico_bin, prefix = \"fico_bin_dum\"))\n",
    "    bins = bins.join(pd.get_dummies(income_bin, prefix = \"income_bin_dum\"))\n",
    "    bins = bins.join(pd.get_dummies(ltv_bin, prefix = \"ltv_bin_dum\"))\n",
    "    bins[\"ltv_80_dum_0\"] = 1 - ltv_80\n",
    "    bins['const'] = 1\n",
    "    return bins\n",
    "\n",
    "# predict on grid\n",
    "def predict(df,clfs,models,features,sato):\n",
    "    dfc = df.copy()\n",
    "    grid = {}\n",
    "    for name in clfs:\n",
    "        grid[name] = pd.DataFrame(index=dfc.index,columns = sato)\n",
    "        for s in sato:\n",
    "            print(name + ', ' + str(s))\n",
    "            dfc[\"sato\"] = s\n",
    "            if name.startswith('Logit'): \n",
    "                    grid[name][s] = models[name].predict(dfc[features[name]]) \n",
    "            else:\n",
    "                    grid[name][s] = models[name].predict_proba(dfc[features[name]])[:,1]\n",
    "    return grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eqsolve(df,grid,sato,params,sda_params,draw=False):\n",
    "    # setup for npv\n",
    "    base_index = np.argmin(abs(sato))\n",
    "    base = (df[\"cur_int_rate\"] - df[\"sato\"]).values.reshape(-1,1) \n",
    "    wacc = (100 + base - params['av_premium']) / 100\n",
    "    repayment = (100 + base + sato) / 100\n",
    "    recovery = 100 * params[\"delta\"] * params[\"gamma\"] / df[\"ltv_ratio_fill\"].values.reshape(-1,1)\n",
    "    recovery = np.minimum(recovery,repayment) - params[\"phi\"] \n",
    "\n",
    "    # equilibrium computation\n",
    "    eq = pd.DataFrame(index = df.index, columns = clfs)\n",
    "    grida = {}\n",
    "    P = {}\n",
    "    npv = {}\n",
    "    nplot = 20\n",
    "    if draw: fig,ax = plt.subplots(1,len(clfs),figsize = (12,6),sharex=True,sharey=True)\n",
    "    for i,name in enumerate(clfs):\n",
    "        grida[name] = adjust(grid[name],params['bias'],base_index)\n",
    "        P[name] = sda(grida[name],sda_params)\n",
    "        npv[name] = (1-P[name]) * repayment + P[name] * recovery - wacc\n",
    "        pos = (npv[name]>0)\n",
    "\n",
    "        # test: all NPV vectors should start negative, otherwise WACC is too low \n",
    "        if np.any(pos[:,0]):\n",
    "            ix = np.argmax(pos[:,0])\n",
    "            raise ValueError('NPV in row %d starts positive, adjust parameters' % ix)\n",
    "\n",
    "        # find smallest positive element with argmax -- if this returns 0, then reject\n",
    "        ix = np.argmax(pos,axis=1)\n",
    "        accept = ix>0\n",
    "\n",
    "        # linear interpolation for solution\n",
    "        n0 = npv[name][accept,ix[accept]-1]; n1 = npv[name][accept,ix[accept]]\n",
    "        s0 = sato[ix[accept]-1]; s1 = sato[ix[accept]]\n",
    "        slope = (n1 - n0) / (s1 - s0)\n",
    "        sol = s0 - n0 / slope\n",
    "\n",
    "        eq[name].iloc[accept] = sol\n",
    "\n",
    "        # illustration\n",
    "        if draw:\n",
    "            ax[i].plot(sato,npv[name][0:nplot,:].T,'--o',alpha = 0.5)\n",
    "            nacc = accept[0:nplot].sum()\n",
    "            ax[i].plot(sol[0:nacc],np.zeros(nacc),'ok',markersize = 10)\n",
    "            ax[i].plot(sato,np.zeros(sato.shape[0]))\n",
    "            ax[i].set_ylabel('NPV, Bias = %.2f' % params['bias'])\n",
    "            ax[i].set_title(name)\n",
    "            ax[i].set_xlabel('sato')\n",
    "            sns.distplot(sol,ax = ax[i].twinx()).set(yticks=[])\n",
    "\n",
    "    if draw: plt.savefig(path2 + 'fig_eqm_illustration.pdf')\n",
    "    return eq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load and clean data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/psg24/opt/anaconda3/lib/python3.8/site-packages/numpy/lib/arraysetops.py:583: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
      "  mask |= (ar1 == a)\n",
      "<ipython-input-5-a951d83ddf97>:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  race[~race.isin(plotrace)] = \"Other\"\n"
     ]
    }
   ],
   "source": [
    "# set paths to saved data\n",
    "path = '../../data/'\n",
    "\n",
    "# data\n",
    "df = pd.read_csv(path + 'all_vals_race0_interestrate1.csv')\n",
    "race = pd.read_csv(path + 'race_clean.csv',index_col=0); df[\"Race\"] = race[\"Race\"]\n",
    "\n",
    "\n",
    "# take random sample\n",
    "df = df.sample(n=10000,random_state=2)\n",
    "race = df[\"Race\"]\n",
    "race[~race.isin(plotrace)] = \"Other\"\n",
    "minority = (race == \"Black\")| (race == \"White Hispanic\")\n",
    "\n",
    "# make bins for logit prediction\n",
    "bins = mkbins(df)\n",
    "df = df.join(bins)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "path2 = '../../output/'\n",
    "# saved classifiers\n",
    "models = {}; features = {}\n",
    "for name in clfs:\n",
    "    if name.startswith('Logit'):\n",
    "        models[name] = pickle.load(open(path2 + name + \"_race0_interestrate1.pkl\",'rb'))\n",
    "        features[name] = list(models[name].params.index)\n",
    "    else:\n",
    "        models[name] = joblib.load(open(path2 + name + \"_race0_interestrate1.pkl\",'rb'))\n",
    "        features[name] = [x.lower() for x in list(pd.read_csv(path + 'feature_names_norace' + name + '.csv').columns)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table VII:  Equilibrium outcomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogitNonLinear, -0.7\n",
      "LogitNonLinear, -0.6\n",
      "LogitNonLinear, -0.5\n",
      "LogitNonLinear, -0.4\n",
      "LogitNonLinear, -0.30000000000000004\n",
      "LogitNonLinear, -0.20000000000000007\n",
      "LogitNonLinear, -0.10000000000000009\n",
      "LogitNonLinear, -1.1102230246251565e-16\n",
      "LogitNonLinear, 0.09999999999999987\n",
      "LogitNonLinear, 0.19999999999999984\n",
      "LogitNonLinear, 0.2999999999999998\n",
      "LogitNonLinear, 0.3999999999999997\n",
      "LogitNonLinear, 0.4999999999999998\n",
      "LogitNonLinear, 0.5999999999999999\n",
      "LogitNonLinear, 0.6999999999999997\n",
      "LogitNonLinear, 0.7999999999999996\n",
      "LogitNonLinear, 0.8999999999999997\n",
      "LogitNonLinear, 0.9999999999999998\n",
      "LogitNonLinear, 1.0999999999999996\n",
      "LogitNonLinear, 1.1999999999999995\n",
      "LogitNonLinear, 1.2999999999999996\n",
      "LogitNonLinear, 1.3999999999999997\n",
      "LogitNonLinear, 1.4999999999999993\n",
      "RandomForestIsotonic, -0.7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.1s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.1s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestIsotonic, -0.6\n",
      "RandomForestIsotonic, -0.5\n",
      "RandomForestIsotonic, -0.4\n",
      "RandomForestIsotonic, -0.30000000000000004\n",
      "RandomForestIsotonic, -0.20000000000000007\n",
      "RandomForestIsotonic, -0.10000000000000009\n",
      "RandomForestIsotonic, -1.1102230246251565e-16\n",
      "RandomForestIsotonic, 0.09999999999999987\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestIsotonic, 0.19999999999999984\n",
      "RandomForestIsotonic, 0.2999999999999998\n",
      "RandomForestIsotonic, 0.3999999999999997\n",
      "RandomForestIsotonic, 0.4999999999999998\n",
      "RandomForestIsotonic, 0.5999999999999999\n",
      "RandomForestIsotonic, 0.6999999999999997\n",
      "RandomForestIsotonic, 0.7999999999999996\n",
      "RandomForestIsotonic, 0.8999999999999997\n",
      "RandomForestIsotonic, 0.9999999999999998\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n",
      "[Parallel(n_jobs=2)]: Using backend ThreadingBackend with 2 concurrent workers.\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s remaining:    0.0s\n",
      "[Parallel(n_jobs=2)]: Done   2 out of   2 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomForestIsotonic, 1.0999999999999996\n",
      "RandomForestIsotonic, 1.1999999999999995\n",
      "RandomForestIsotonic, 1.2999999999999996\n",
      "RandomForestIsotonic, 1.3999999999999997\n",
      "RandomForestIsotonic, 1.4999999999999993\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/psg24/opt/anaconda3/lib/python3.8/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n",
      "/Users/psg24/opt/anaconda3/lib/python3.8/site-packages/pandas/core/indexing.py:1637: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self._setitem_single_block(indexer, value, name)\n",
      "/Users/psg24/opt/anaconda3/lib/python3.8/site-packages/seaborn/distributions.py:2557: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">Accept</th>\n",
       "      <th colspan=\"2\" halign=\"left\">Mean SATO</th>\n",
       "      <th colspan=\"2\" halign=\"left\">SD SATO</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>NL</th>\n",
       "      <th>RF</th>\n",
       "      <th>NL</th>\n",
       "      <th>RF</th>\n",
       "      <th>NL</th>\n",
       "      <th>RF</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Asian</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.191</td>\n",
       "      <td>0.185</td>\n",
       "      <td>0.305</td>\n",
       "      <td>0.292</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>White Non-Hispanic</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.187</td>\n",
       "      <td>0.187</td>\n",
       "      <td>0.296</td>\n",
       "      <td>0.294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>White Hispanic</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.237</td>\n",
       "      <td>0.242</td>\n",
       "      <td>0.327</td>\n",
       "      <td>0.334</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Black</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.182</td>\n",
       "      <td>0.182</td>\n",
       "      <td>0.294</td>\n",
       "      <td>0.296</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Other</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.195</td>\n",
       "      <td>0.195</td>\n",
       "      <td>0.300</td>\n",
       "      <td>0.297</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Population</th>\n",
       "      <td>100.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.192</td>\n",
       "      <td>0.192</td>\n",
       "      <td>0.299</td>\n",
       "      <td>0.296</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cross-group SD</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.008</td>\n",
       "      <td>0.008</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Accept        Mean SATO        SD SATO       \n",
       "                       NL     RF        NL     RF      NL     RF\n",
       "Race                                                            \n",
       "Asian               100.0  100.0     0.191  0.185   0.305  0.292\n",
       "White Non-Hispanic  100.0  100.0     0.187  0.187   0.296  0.294\n",
       "White Hispanic      100.0  100.0     0.237  0.242   0.327  0.334\n",
       "Black               100.0  100.0     0.182  0.182   0.294  0.296\n",
       "Other               100.0  100.0     0.195  0.195   0.300  0.297\n",
       "Population          100.0  100.0     0.192  0.192   0.299  0.296\n",
       "Cross-group SD        0.0    0.0     0.008  0.008     NaN    NaN"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sato = np.arange(-0.7,1.6,0.1) # wider for roubstness\n",
    "\n",
    "#fix for simulated code\n",
    "#dropList = ['prop_state_dum_HI', 'prop_state_dum_ME', 'prop_state_dum_CA', 'loan_type_mcdash_dum_C', 'prop_state_dum_CO', 'prop_state_dum_MD', 'jumbo_flg_dum_N', 'prop_state_dum_KS', 'prop_state_dum_MA', 'prop_state_dum_RI', 'prop_state_dum_VT', 'prop_state_dum_SC', 'prop_state_dum_OR', 'prop_state_dum_OK', 'prop_state_dum_DC', 'prop_state_dum_GA', 'prop_state_dum_PA', 'prop_state_dum_NY', 'prop_state_dum_OH', 'prop_state_dum_UT', 'prop_state_dum_DE', 'prop_state_dum_MT', 'prop_state_dum_NH', 'prop_state_dum_WI', 'prop_state_dum_IA', 'prop_state_dum_SD', 'prop_state_dum_AR', 'prop_state_dum_LA', 'prop_state_dum_IL', 'prop_state_dum_MN', 'prop_state_dum_MO', 'prop_state_dum_NC', 'prop_state_dum_TN', 'prop_state_dum_AL', 'prop_state_dum_AZ', 'prop_state_dum_TX', 'prop_state_dum_ID', 'prop_state_dum_NM', 'prop_state_dum_AK', 'prop_state_dum_WA', 'prop_state_dum_WV', 'prop_state_dum_IN', 'prop_state_dum_FL', 'prop_state_dum_CT', 'prop_state_dum_NV', 'prop_state_dum_MI', 'prop_state_dum_NE', 'prop_state_dum_NJ', 'prop_state_dum_KY', 'prop_state_dum_VA', 'prop_state_dum_MS', 'prop_state_dum_ND']\n",
    "#tempList = set(features[\"RandomForestIsotonic\"])\n",
    "#tempList.difference_update(dropList)\n",
    "#print(list(tempList))\n",
    "#features[\"RandomForestIsotonic\"] = list(tempList)\n",
    "\n",
    "grid = predict(df,clfs,models,features,sato)\n",
    "eq = eqsolve(df,grid,sato,params,sda_params,draw=True)\n",
    "eq = eq.astype('float')\n",
    "\n",
    "def frac_notna(x):\n",
    "    f = 100*(x.count() / x.shape[0])\n",
    "    return f\n",
    "\n",
    "stats = {}\n",
    "\n",
    "tabrace = plotrace + [\"Other\"]\n",
    "\n",
    "accept = eq.groupby(race).agg(frac_notna).loc[tabrace]\n",
    "cross_accept = eq.groupby(race).transform(frac_notna).std().rename(\"Cross-group SD\")\n",
    "pop_accept = pd.Series(eq.apply(frac_notna),name = \"Population\")\n",
    "stats[\"Accept\"] = accept.append(pop_accept).append(cross_accept)\n",
    "\n",
    "eqrate = eq.groupby(race).mean()\n",
    "cross_eqrate = eq.groupby(race).transform('mean').std().rename(\"Cross-group SD\")\n",
    "pop_eqrate = pd.Series(eq.mean(),name = \"Population\")\n",
    "stats[\"Mean SATO\"] = eqrate.append(pop_eqrate).append(cross_eqrate)\n",
    "\n",
    "sdrate = eq.groupby(race).std()\n",
    "pop_sdrate = pd.Series(eq.std(),name = \"Population\")\n",
    "stats[\"SD SATO\"] = sdrate.append(pop_sdrate)\n",
    "\n",
    "\n",
    "stats = pd.concat(stats,axis=1,sort=False).round(3).rename(columns = {clfs[0]:'NL',clfs[1]:'RF'})\n",
    "display(stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
